#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <linux/videodev2.h>
#include <poll.h>
#include <string.h>
#include <linux/fb.h>
#include <stdlib.h>
#include <math.h>
#include <wchar.h>
#include <time.h>
#include <string.h>

#include <locale.h>
#include <ft2build.h> /*要先编译安装矢量字库*/
#include FT_FREETYPE_H
#include FT_STROKER_H

#include <jpeglib.h>
#include <jerror.h>



/*定义一个结构体存放矢量字体的配置--------------*/
struct FREE_TYPE_CONFIG
{
	FT_Library    library;
	FT_Face       face;
	FT_GlyphSlot  slot;
	FT_Vector     pen;                    /* untransformed origin  */
	FT_Error      error;
	FT_BBox  bbox;
	FT_Glyph  glyph;
};
struct FREE_TYPE_CONFIG FreeTypeConfig;

typedef unsigned int u32;
typedef unsigned short u16;
typedef unsigned char u8;


int video_fd;
char *video_buff_buff[4]; /*保存摄像头缓冲区的地址*/
int video_height=0;
int video_width=0;

//这是转换之后的RGB数据首地址
unsigned char *rgb_p=NULL;
	


 /*jpeg压缩函数
 *@rgb：指向存放rgb24数据的起始地址
 *@width：屏幕（分辨率）的宽度
 *@height：屏幕（分辨率）的高度
 */
 int SaveJPGImage(unsigned char *rgb,int width,int height,char *file_name)
 {
     struct jpeg_compress_struct cinfo;
     struct jpeg_error_mgr jerr;
     FILE * outfile;
     JSAMPROW row_pointer[1];
     int row_stride;
	 memset(&cinfo,0,sizeof(struct jpeg_compress_struct));
	 
	 /*1. 注册错误处理方式*/
     cinfo.err = jpeg_std_error(&jerr);
	 
	 /*2. 创建jpeg压缩对象*/
     jpeg_create_compress(&cinfo);
     if ((outfile = fopen(file_name, "wb")) == NULL)
     {
         printf("文件创建失败.jpg\n");
         return -1;
     }
	 
	 /*3. 指定压缩后图像存放的目标文件*/
     jpeg_stdio_dest(&cinfo,outfile);
	
	 /*4. 配置输出的JPEG图像的参数信息*/
     cinfo.image_width = width;      //宽
     cinfo.image_height = height;    //高
     cinfo.input_components = 3;     //像素（3表示彩色）
     cinfo.in_color_space = JCS_RGB; //输入数据格式为RGB(彩色)
	 
	 /*5. 设置默认JPEG参数*/
     jpeg_set_defaults(&cinfo);
     
	 /*6. 配置JPEG图像压缩质量为80*/
     jpeg_set_quality(&cinfo,80,TRUE);
	 
	 /*7. 开始压缩*/
     jpeg_start_compress(&cinfo,TRUE);
	 
     row_stride = width * 3; //一行的字节数

	 /*8. 一行一行进行压缩*/
     while(cinfo.next_scanline < cinfo.image_height)
     {
		 //得到每一行的数据地址
         row_pointer[0] = &rgb[cinfo.next_scanline * row_stride];
		 //将压缩后的数据写入到文件
         (void) jpeg_write_scanlines(&cinfo,row_pointer,1);
     }
	 
	 /*9. 结束解压缩操作*/
     jpeg_finish_compress(&cinfo);
	 
	 /*10. 关闭文件*/
     fclose(outfile);
	
	 /*11. 销毁压缩使用的结构体，释放空间*/
     jpeg_destroy_compress(&cinfo);
     return 1;
}


/*
函数功能: 显示像素点
*/
void Display_Point(char *head,int w,int x,int y,int c)
{
    unsigned char *p=(unsigned char *)(head+w*3*y+x*3);
    *(p+0)=(c>>0)&0xFF;
    *(p+1)=(c>>8)&0xFF;
    *(p+2)=(c>>16)&0xFF;
}


/*	LCD显示矢量字体的位图信息
 *		bitmap : 要显示的字体的矢量位图
 *		x : 显示的x坐标
 *		y : 显示的y坐标
 */
void LCD_DrawBitmap(FT_Bitmap* bitmap,FT_Int x,FT_Int y)
{
  	FT_Int i,j,p,q;
  	FT_Int x_max=x+bitmap->width;
  	FT_Int y_max=y+bitmap->rows;

	/* 将位图信息循环打印到屏幕上 */
	for(i=x,p=0;i<x_max;i++,p++)
	{
		for(j=y,q=0;j<y_max;j++,q++)
		{
			if((i>x_max)||(j>y_max)||(i<0)||(j<0))continue;
			if(bitmap->buffer[q*bitmap->width+p]!=0)
			{
				Display_Point(rgb_p,video_width,i, j,0xFF0033);
			}
			else
			{
				//画背景
				//Display_Point(rgb_p,video_width,i, j,0xFFFFFF);
			}
		}
	}
}

/*
函数功能: 初始化FreeType配置
*/
int InitConfig_FreeType(char *font_file)
{
	FT_Error      error;
	/*1. 初始化freetype库*/
	error=FT_Init_FreeType(&FreeTypeConfig.library);
	if(error)
	{
		printf("freetype字体库初始化失败.\n");
		return -1;
	}

	/*2. 打开加载的字体文件*/
 	error=FT_New_Face(FreeTypeConfig.library,font_file,0,&FreeTypeConfig.face);
  	if(error)
  	{
		printf("矢量字体文件加载失败.\n");
		return -2;
	}
	return 0;
}

/*
函数功能: 释放FreeType配置
*/
void FreeType_Config(void)
{
	FT_Done_Face(FreeTypeConfig.face);
  	FT_Done_FreeType(FreeTypeConfig.library);
}

/*
函数功能: 在LCD屏显示一串文本数据
函数参数:
	u32 x   坐标位置
	u32 y   坐标位置
	u32 size 字体大小
	wchar_t *text 显示的文本数据
*/
int LCD_DrawText(u32 x,u32 y,u32 size,wchar_t *text)
{
	FT_Error      error;
	int i = 0;
	int bbox_height_min = 10000;
	int bbox_height_max = 0;
		
	/*3. 设置字符的像素的大小为size*size*/
	error=FT_Set_Pixel_Sizes(FreeTypeConfig.face,size,0);
	if(error)
	{
		printf("字符的像素大小设置失败.\n");
		return -1;
	}
	
	/*4. 设置字体文件的轮廓的插槽*/
	FreeTypeConfig.slot=FreeTypeConfig.face->glyph;

	/* 设置坐标为原点坐标
	 * 将LCD坐标转换成笛卡尔坐标
	 * 单位是 1/64 Point
	 */
	FreeTypeConfig.pen.x=x*64;
  	FreeTypeConfig.pen.y=(video_height-size-y)*64;

	/*5. 循环的将文字显示出来*/
	for(i=0;i<wcslen(text);i++)
	{
		FT_Set_Transform(FreeTypeConfig.face,0,&FreeTypeConfig.pen);	//设置字体的起始坐标位置
		/*装载字符编码，填充face的glyph slot成员*/
		error=FT_Load_Char(FreeTypeConfig.face,text[i],FT_LOAD_RENDER);
		if(error)
		{
			printf("装载字符编码失败.\n");
			return -1;
		}
		
		/*通过glyph slot来获得glyph*/
		FT_Get_Glyph(FreeTypeConfig.slot,&FreeTypeConfig.glyph);

		/*通过glyph来获得cbox*/
		FT_Glyph_Get_CBox(FreeTypeConfig.glyph,FT_GLYPH_BBOX_TRUNCATE,&FreeTypeConfig.bbox);

		/*获得字体高度的最大值和最小值*/
		if(bbox_height_min>FreeTypeConfig.bbox.yMin)bbox_height_min=FreeTypeConfig.bbox.yMin;
		if(bbox_height_max<FreeTypeConfig.bbox.yMax)bbox_height_max=FreeTypeConfig.bbox.yMax;
		
		/*画点，把笛卡尔坐标转换成LCD坐标*/
		LCD_DrawBitmap(&FreeTypeConfig.slot->bitmap,
						FreeTypeConfig.slot->bitmap_left,
						video_height-FreeTypeConfig.slot->bitmap_top);

		if(FreeTypeConfig.slot->bitmap_left+size*2>video_width)
		{
			FreeTypeConfig.pen.x=0; //更新X坐标位置
			FreeTypeConfig.pen.y=(video_height-size-y-size)*64; //更新Y坐标位置
		}
		else
		{
			/* 更新原点坐标位置 */
			FreeTypeConfig.pen.x+=FreeTypeConfig.slot->advance.x;
			FreeTypeConfig.pen.y+=FreeTypeConfig.slot->advance.y;
		}
	}
	return 0;
}

// 将char类型转化为wchar
// src:  源
// dest: 目标
// locale: 环境变量的值，mbstowcs依赖此值来判断src的编码方式
void CharToWchar(char *src, wchar_t *dest)
{
  // 根据环境变量设置locale
  setlocale(LC_CTYPE,"zh_CN.utf8");
  // mbstowcs函数得到转化为需要的宽字符大小: 计算char转为wcchar存放时实际占用空间大小.
  // 也可以直接传入一个大数组代替
  //w_size=mbstowcs(NULL, src, 0) + 1;
  mbstowcs(dest, src, strlen(src)+1);
}


/*初始化摄像头设备*/
int VideoDev_Init(const char *dev_path)
{
	/*1. 打开摄像头设备*/
	video_fd=open(dev_path,2);
	if(video_fd<0)return -1;
	/*2. 设置摄像头的输出图像尺寸与图像格式*/
	struct v4l2_format video_format;
	memset(&video_format,0,sizeof(struct v4l2_format));
	video_format.type=V4L2_BUF_TYPE_VIDEO_CAPTURE; //捕获设备
	video_format.fmt.pix.height=480;
	video_format.fmt.pix.width=800;
	video_format.fmt.pix.pixelformat=V4L2_PIX_FMT_YUYV;
	if(ioctl(video_fd,VIDIOC_S_FMT,&video_format))return -2;
	printf("当前摄像头支持的分辨率:%dx%d\n",video_format.fmt.pix.width,video_format.fmt.pix.height);
	if(video_format.fmt.pix.pixelformat!=V4L2_PIX_FMT_YUYV)
	{
		printf("当前摄像头不支持YUYV格式输出.\n");
		return -3;
	}
	else
	{
		video_height=video_format.fmt.pix.height;
		video_width=video_format.fmt.pix.width;	
		printf("当前摄像头支持YUYV格式输出.\n");
	}
	/*3. 申请缓冲区*/
	struct v4l2_requestbuffers video_requestbuffers;
	memset(&video_requestbuffers,0,sizeof(struct v4l2_requestbuffers));
	video_requestbuffers.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
	video_requestbuffers.count=4;
	video_requestbuffers.memory=V4L2_MEMORY_MMAP;
	if(ioctl(video_fd,VIDIOC_REQBUFS,&video_requestbuffers))return -4;
	printf("成功申请的缓冲区数量:%d\n",video_requestbuffers.count);
	/*4. 得到每个缓冲区的地址: 将申请的缓冲区映射到进程空间*/
	struct v4l2_buffer video_buffer;
	memset(&video_buffer,0,sizeof(struct v4l2_buffer));
	int i;
	for(i=0;i<video_requestbuffers.count;i++)
	{
		video_buffer.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
		video_buffer.index=i;
		video_buffer.memory=V4L2_MEMORY_MMAP;
		if(ioctl(video_fd,VIDIOC_QUERYBUF,&video_buffer))return -5;
		/*映射缓冲区的地址到进程空间*/
		video_buff_buff[i]=mmap(NULL,video_buffer.length,PROT_READ|PROT_WRITE,MAP_SHARED,video_fd,video_buffer.m.offset);
		printf("第%d个缓冲区地址:%#X\n",i,video_buff_buff[i]);
	}	
	/*5. 将缓冲区放入到采集队列*/
	memset(&video_buffer,0,sizeof(struct v4l2_buffer));
	for(i=0;i<video_requestbuffers.count;i++)
	{
		video_buffer.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
		video_buffer.index=i;
		video_buffer.memory=V4L2_MEMORY_MMAP;
		if(ioctl(video_fd,VIDIOC_QBUF,&video_buffer))return -6;
	}
	/*6. 启动摄像头采集*/
	int opt_type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
	if(ioctl(video_fd,VIDIOC_STREAMON,&opt_type))return -7;
	return 0;
}

/*
将YUV格式数据转为RGB
*/
void yuv_to_rgb(unsigned char *yuv_buffer,unsigned char *rgb_buffer,int iWidth,int iHeight)
{
	int x;
	int z=0;
	unsigned char *ptr = rgb_buffer;
	unsigned char *yuyv= yuv_buffer;
	for (x = 0; x < iWidth*iHeight; x++)
	{
		int r, g, b;
		int y, u, v;
		if (!z)
		y = yuyv[0] << 8;
		else
		y = yuyv[2] << 8;
		u = yuyv[1] - 128;
		v = yuyv[3] - 128;
		r = (y + (359 * v)) >> 8;
		g = (y - (88 * u) - (183 * v)) >> 8;
		b = (y + (454 * u)) >> 8;
		
		//颜色如果有问题,更换这里的顺序
		*(ptr++) = (r > 255) ? 255 : ((r < 0) ? 0 : r);
		*(ptr++) = (g > 255) ? 255 : ((g < 0) ? 0 : g);
		*(ptr++) = (b > 255) ? 255 : ((b < 0) ? 0 : b);		
		if(z++)
		{
			z = 0;
			yuyv += 4;
		}
	}
}



//需要先把摄像头挂载到虚拟机里
//[root@wbyq code]# ./app /dev/video0 simhei.ttf 
//[root@wbyq code]# date -s "2020-09-19 09:39:20"


//编译程序记得加上-lfreetype
int main(int argc,char **argv)
{
	if(argc!=3)
	{
		printf("传参格式:./app </dev/videoX> <矢量字体文件>\n");
		return 0;
	}
	/*初始化配置FreeType*/
	InitConfig_FreeType(argv[2]);
	
	/*1. 初始化摄像头*/
	printf("摄像头初始化状态:%d\n",VideoDev_Init(argv[1]));
	
	/*2. 读取摄像头的数据*/
	struct pollfd video_fds;
	video_fds.events=POLLIN;
	video_fds.fd=video_fd;
	struct v4l2_buffer video_buffer;
	memset(&video_buffer,0,sizeof(struct v4l2_buffer));
	
	//转换RGB需要的缓冲区
	unsigned char *rgb_buffer=malloc(video_height*video_width*3);

	time_t sec;
	struct tm c_timedate;
	char time_date[50];
	wchar_t time_date_wchar[100];
	
	char file_name[100];
	int file_name_cnt=0;
	while(1)
	{
		/*等待摄像头采集数据*/
		poll(&video_fds,1,-1);
		/*得到缓冲区的编号*/
		video_buffer.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;
		video_buffer.memory=V4L2_MEMORY_MMAP;
		ioctl(video_fd,VIDIOC_DQBUF,&video_buffer);
		//printf("当前采集OK的缓冲区编号:%d,地址:%#X\n",video_buffer.index,video_buff_buff[video_buffer.index]);
		/*对缓冲区数据进行处理*/
		yuv_to_rgb(video_buff_buff[video_buffer.index],rgb_buffer,video_width,video_height);
		
		/*这是转换后的RGB数据*/
		rgb_p=rgb_buffer;

		/*获取本地时间*/
		sec=time(NULL); //获取当前系统的秒单位时间
		localtime_r(&sec,&c_timedate); //将秒单位时间转为结构体返回
		
		sprintf(time_date,"%d-%d-%d %d:%d:%d",c_timedate.tm_year+1900,c_timedate.tm_mon+1,c_timedate.tm_mday,c_timedate.tm_hour,c_timedate.tm_min,c_timedate.tm_sec);
		
		//printf("time_date=%s\n",time_date);

		//char类型转Wchar
		CharToWchar(time_date,time_date_wchar);
		
		LCD_DrawText(0,0,32,L"矢量字体加水印");
		LCD_DrawText(0,32,32,time_date_wchar);
			
		sprintf(file_name,"%d.jpg",file_name_cnt++);
		
		//保存成JPG图片
		SaveJPGImage(rgb_p,video_width,video_height,file_name);
		
		printf("保存图片:%s\n",file_name);
		
		/*将缓冲区放入采集队列*/
		ioctl(video_fd,VIDIOC_QBUF,&video_buffer);
	}
	
	/*4. 关闭视频设备*/
	close(video_fd);
	return 0;
}

